using Microsoft.Extensions.Logging;

namespace JGSY.CMS.LowCode.Platform.Infrastructure.Configuration;

/// <summary>
/// 模板引擎处理器 - 扩展UnifiedConfigurationProcessor的模板相关功能
/// </summary>
public static class TemplateEngineProcessor
{
    /// <summary>
    /// 渲染模板内容 - 根据引擎类型分发处理
    /// </summary>
    /// <param name="content">模板内容</param>
    /// <param name="data">数据对象</param>
    /// <param name="engine">引擎名称</param>
    /// <param name="logger">日志记录器</param>
    /// <returns>渲染结果</returns>
    public static async Task<string> RenderAsync(string content, object data, string engine, ILogger? logger = null)
    {
        var engineType = UnifiedConfigurationProcessor.NormalizeTemplateEngine(engine);
        
        logger?.LogInformation("开始渲染模板，引擎: {Engine}", UnifiedConfigurationProcessor.GetTemplateEngineDisplayName(engineType));
        
        try
        {
            return engineType switch
            {
                UnifiedConfigurationProcessor.TemplateEngine.Razor => await RenderRazorAsync(content, data, logger),
                UnifiedConfigurationProcessor.TemplateEngine.Liquid => await RenderLiquidAsync(content, data, logger),
                UnifiedConfigurationProcessor.TemplateEngine.Handlebars => await RenderHandlebarsAsync(content, data, logger),
                UnifiedConfigurationProcessor.TemplateEngine.Mustache => await RenderMustacheAsync(content, data, logger),
                _ => throw new NotSupportedException($"不支持的模板引擎: {engine}")
            };
        }
        catch (Exception ex)
        {
            logger?.LogError(ex, "模板渲染失败，引擎: {Engine}", engine);
            throw new InvalidOperationException($"模板渲染失败: {ex.Message}", ex);
        }
    }

    /// <summary>
    /// 验证模板语法 - 根据引擎类型分发处理
    /// </summary>
    /// <param name="content">模板内容</param>
    /// <param name="engine">引擎名称</param>
    /// <param name="logger">日志记录器</param>
    /// <returns>验证结果</returns>
    public static async Task<(bool IsValid, string[] Errors)> ValidateAsync(string content, string engine, ILogger? logger = null)
    {
        if (string.IsNullOrEmpty(content))
        {
            return (false, new[] { "模板内容不能为空" });
        }

        var engineType = UnifiedConfigurationProcessor.NormalizeTemplateEngine(engine);
        
        logger?.LogInformation("开始验证模板语法，引擎: {Engine}", UnifiedConfigurationProcessor.GetTemplateEngineDisplayName(engineType));

        try
        {
            var errors = engineType switch
            {
                UnifiedConfigurationProcessor.TemplateEngine.Razor => await ValidateRazorAsync(content, logger),
                UnifiedConfigurationProcessor.TemplateEngine.Liquid => await ValidateLiquidAsync(content, logger),
                UnifiedConfigurationProcessor.TemplateEngine.Handlebars => await ValidateHandlebarsAsync(content, logger),
                UnifiedConfigurationProcessor.TemplateEngine.Mustache => await ValidateMustacheAsync(content, logger),
                _ => new List<string> { $"不支持的模板引擎: {engine}" }
            };

            var isValid = errors.Count == 0;
            logger?.LogInformation("模板验证完成，引擎: {Engine}, 是否有效: {IsValid}, 错误数量: {ErrorCount}", 
                UnifiedConfigurationProcessor.GetTemplateEngineDisplayName(engineType), isValid, errors.Count);

            return (isValid, errors.ToArray());
        }
        catch (Exception ex)
        {
            logger?.LogError(ex, "模板验证异常，引擎: {Engine}", engine);
            return (false, new[] { $"模板验证异常: {ex.Message}" });
        }
    }

    #region Razor引擎处理

    /// <summary>
    /// 渲染Razor模板
    /// </summary>
    private static async Task<string> RenderRazorAsync(string content, object data, ILogger? logger)
    {
        // 注意：实际项目中需要安装RazorEngine或类似的包
        logger?.LogDebug("使用Razor引擎渲染模板");
        
        // 这里是示例实现，实际需要集成Razor引擎
        await Task.Delay(1); // 避免编译器警告
        return $"<!-- Razor渲染结果 -->\n{content}\n<!-- 数据: {System.Text.Json.JsonSerializer.Serialize(data)} -->";
    }

    /// <summary>
    /// 验证Razor模板
    /// </summary>
    private static async Task<List<string>> ValidateRazorAsync(string content, ILogger? logger)
    {
        var errors = new List<string>();
        
        logger?.LogDebug("验证Razor模板语法");
        
        // 简单的语法检查
        if (!content.Contains("@") && content.Contains("{{"))
        {
            errors.Add("检测到可能的Handlebars语法，但当前是Razor引擎");
        }
        
        // 这里可以添加更复杂的Razor语法验证逻辑
        await Task.Delay(1); // 避免编译器警告
        
        return errors;
    }

    #endregion

    #region Liquid引擎处理

    /// <summary>
    /// 渲染Liquid模板
    /// </summary>
    private static async Task<string> RenderLiquidAsync(string content, object data, ILogger? logger)
    {
        // 注意：实际项目中需要安装Liquid.NET或类似的包
        logger?.LogDebug("使用Liquid引擎渲染模板");
        
        await Task.Delay(1); // 避免编译器警告
        return $"<!-- Liquid渲染结果 -->\n{content}\n<!-- 数据: {System.Text.Json.JsonSerializer.Serialize(data)} -->";
    }

    /// <summary>
    /// 验证Liquid模板
    /// </summary>
    private static async Task<List<string>> ValidateLiquidAsync(string content, ILogger? logger)
    {
        var errors = new List<string>();
        
        logger?.LogDebug("验证Liquid模板语法");
        
        // 简单的语法检查
        if (!content.Contains("{%") && !content.Contains("{{") && content.Contains("@"))
        {
            errors.Add("检测到可能的Razor语法，但当前是Liquid引擎");
        }
        
        await Task.Delay(1); // 避免编译器警告
        
        return errors;
    }

    #endregion

    #region Handlebars引擎处理

    /// <summary>
    /// 渲染Handlebars模板
    /// </summary>
    private static async Task<string> RenderHandlebarsAsync(string content, object data, ILogger? logger)
    {
        // 注意：实际项目中需要安装HandlebarsDotNet或类似的包
        logger?.LogDebug("使用Handlebars引擎渲染模板");
        
        await Task.Delay(1); // 避免编译器警告
        return $"<!-- Handlebars渲染结果 -->\n{content}\n<!-- 数据: {System.Text.Json.JsonSerializer.Serialize(data)} -->";
    }

    /// <summary>
    /// 验证Handlebars模板
    /// </summary>
    private static async Task<List<string>> ValidateHandlebarsAsync(string content, ILogger? logger)
    {
        var errors = new List<string>();
        
        logger?.LogDebug("验证Handlebars模板语法");
        
        // 简单的语法检查
        if (!content.Contains("{{") && content.Contains("@"))
        {
            errors.Add("检测到可能的Razor语法，但当前是Handlebars引擎");
        }
        
        await Task.Delay(1); // 避免编译器警告
        
        return errors;
    }

    #endregion

    #region Mustache引擎处理

    /// <summary>
    /// 渲染Mustache模板
    /// </summary>
    private static async Task<string> RenderMustacheAsync(string content, object data, ILogger? logger)
    {
        // 注意：实际项目中需要安装Mustache.NET或类似的包
        logger?.LogDebug("使用Mustache引擎渲染模板");
        
        await Task.Delay(1); // 避免编译器警告
        return $"<!-- Mustache渲染结果 -->\n{content}\n<!-- 数据: {System.Text.Json.JsonSerializer.Serialize(data)} -->";
    }

    /// <summary>
    /// 验证Mustache模板
    /// </summary>
    private static async Task<List<string>> ValidateMustacheAsync(string content, ILogger? logger)
    {
        var errors = new List<string>();
        
        logger?.LogDebug("验证Mustache模板语法");
        
        // 简单的语法检查
        if (!content.Contains("{{") && content.Contains("@"))
        {
            errors.Add("检测到可能的Razor语法，但当前是Mustache引擎");
        }
        
        await Task.Delay(1); // 避免编译器警告
        
        return errors;
    }

    #endregion

    #region 辅助方法

    /// <summary>
    /// 获取支持的模板引擎列表
    /// </summary>
    /// <returns>支持的引擎列表</returns>
    public static List<string> GetSupportedEngines()
    {
        return Enum.GetValues<UnifiedConfigurationProcessor.TemplateEngine>()
            .Select(e => UnifiedConfigurationProcessor.GetTemplateEngineDisplayName(e))
            .ToList();
    }

    /// <summary>
    /// 检查引擎是否受支持
    /// </summary>
    /// <param name="engine">引擎名称</param>
    /// <returns>是否支持</returns>
    public static bool IsEngineSupported(string engine)
    {
        try
        {
            UnifiedConfigurationProcessor.NormalizeTemplateEngine(engine);
            return true;
        }
        catch
        {
            return false;
        }
    }

    /// <summary>
    /// 获取引擎的默认文件扩展名
    /// </summary>
    /// <param name="engine">引擎名称</param>
    /// <returns>文件扩展名</returns>
    public static string GetDefaultFileExtension(string engine)
    {
        var engineType = UnifiedConfigurationProcessor.NormalizeTemplateEngine(engine);
        return UnifiedConfigurationProcessor.GetTemplateEngineFileExtension(engineType);
    }

    #endregion
}
